home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1995 #5 & #6 / Amiga Plus CD - 1995 - No. 5 and 6.iso / pd / netz / term / extras / source / term-source.lha / termPickFile.c < prev    next >
C/C++ Source or Header  |  1995-02-15  |  15KB  |  709 lines
  1. /*
  2. **    termPickFile.c
  3. **
  4. **    Simplified file selection routines
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. #include <exec/resident.h>
  13.  
  14. enum    {    GAD_LIST=1,GAD_USE,GAD_SELECT,GAD_CANCEL };
  15.  
  16. BOOLEAN __regargs
  17. ValidateFile(STRPTR FileName,LONG Type,STRPTR RealName)
  18. {
  19.     BOOLEAN    Valid = FALSE;
  20.     BPTR    Segment;
  21.  
  22.     if(Segment = LoadSeg(FileName))
  23.     {
  24.         ULONG    *SegmentData;
  25.         BPTR     SegPtr = Segment;
  26.         UWORD    *Match;
  27.         BOOLEAN     GotIt = FALSE;
  28.         LONG     Size;
  29.  
  30.         do
  31.         {
  32.             SegmentData = (ULONG *)BADDR(SegPtr);
  33.  
  34.             SegPtr    = (BPTR)SegmentData[0];
  35.             Size    = SegmentData[-1] - 2 * sizeof(ULONG) - sizeof(struct Resident);
  36.             Match    = (UWORD *)(SegmentData + 1);
  37.  
  38.             while(!GotIt && Size > 0)
  39.             {
  40.                 if(*Match == RTC_MATCHWORD)
  41.                 {
  42.                     struct Resident *Resident = (struct Resident *)Match;
  43.  
  44.                     if(Resident -> rt_MatchTag == Resident)
  45.                     {
  46.                         if(Resident -> rt_Type == Type && Resident -> rt_Name)
  47.                         {
  48.                             if(!Stricmp(FilePart(FileName),Resident -> rt_Name))
  49.                             {
  50.                                 if(RealName)
  51.                                     strcpy(RealName,Resident -> rt_Name);
  52.  
  53.                                 Valid = TRUE;
  54.                             }
  55.                         }
  56.  
  57.                         GotIt = TRUE;
  58.                     }
  59.                 }
  60.  
  61.                 Match    += 2;
  62.                 Size    -= sizeof(ULONG);
  63.             }
  64.         }
  65.         while(!GotIt && SegPtr);
  66.  
  67.         UnLoadSeg(Segment);
  68.     }
  69.  
  70.     return(Valid);
  71. }
  72.  
  73.     /* AddFile(struct List *List,STRPTR Name):
  74.      *
  75.      *    Add another file to the list:
  76.      */
  77.  
  78. STATIC VOID __regargs
  79. AddFile(struct List *List,STRPTR Name)
  80. {
  81.     struct Node *NewNode;
  82.  
  83.     if(NewNode = CreateNode(Name))
  84.     {
  85.         struct Node    *Node,
  86.                 *Next;
  87.         BYTE         GotIt = FALSE;
  88.         LONG         Result;
  89.  
  90.         Node = List -> lh_Head;
  91.  
  92.         while(Next = Node -> ln_Succ)
  93.         {
  94.             if((Result = Stricmp(Name,Node -> ln_Name)) < 0)
  95.             {
  96.                 Insert(List,NewNode,Node -> ln_Pred);
  97.  
  98.                 GotIt = TRUE;
  99.  
  100.                 break;
  101.             }
  102.             else
  103.             {
  104.                     /* Don't add two identical names. */
  105.  
  106.                 if(!Result)
  107.                 {
  108.                     FreeVecPooled(NewNode);
  109.  
  110.                     return;
  111.                 }
  112.             }
  113.  
  114.             Node = Next;
  115.         }
  116.  
  117.         if(!GotIt)
  118.             AddTail(List,NewNode);
  119.     }
  120. }
  121.  
  122.     /* FileMultiScan(struct List *FileList,STRPTR Directory,STRPTR Pattern):
  123.      *
  124.      *    Scan an assignment, also handles multipath assignments.
  125.      */
  126.  
  127. STATIC VOID __regargs
  128. FileMultiScan(struct List *FileList,STRPTR Directory,STRPTR Pattern,LONG Type)
  129. {
  130.     struct DevProc        *DevProc    = NULL;
  131.     struct MsgPort        *FileSysTask    = GetFileSysTask();
  132.     struct FileInfoBlock    *FileInfo;
  133.     UBYTE             MatchBuffer[MAX_FILENAME_LENGTH];
  134.  
  135.     if(ParsePatternNoCase(Pattern,MatchBuffer,MAX_FILENAME_LENGTH) != -1)
  136.     {
  137.             /* Allocate the fileinfo data. */
  138.  
  139.         if(FileInfo = (struct FileInfoBlock *)AllocDosObjectTags(DOS_FIB,TAG_DONE))
  140.         {
  141.                 /* Loop until all assignments are
  142.                  * processed.
  143.                  */
  144.  
  145.             do
  146.             {
  147.                     /* Get the default filesystem task
  148.                      * in case we stumble upon NULL
  149.                      * directory locks.
  150.                      */
  151.  
  152.                 if(DevProc = GetDeviceProc(Directory,DevProc))
  153.                 {
  154.                         /* Set the default filesystem task. */
  155.  
  156.                     SetFileSysTask(DevProc -> dvp_Port);
  157.  
  158.                         /* Check the object type. */
  159.  
  160.                     if(Examine(DevProc -> dvp_Lock,FileInfo))
  161.                     {
  162.                             /* Is it really a directory? */
  163.  
  164.                         if(FileInfo -> fib_DirEntryType > 0)
  165.                         {
  166.                                 /* Scan the directory... */
  167.  
  168.                             while(ExNext(DevProc -> dvp_Lock,FileInfo))
  169.                             {
  170.                                     /* Did we find a file? */
  171.  
  172.                                 if(FileInfo -> fib_DirEntryType < 0)
  173.                                 {
  174.                                         /* Does the name match the template? */
  175.  
  176.                                     if(MatchPatternNoCase(MatchBuffer,FileInfo -> fib_FileName))
  177.                                     {
  178.                                         if(Type == -1)
  179.                                             AddFile(FileList,FileInfo -> fib_FileName);
  180.                                         else
  181.                                         {
  182.                                             UBYTE LocalBuffer[MAX_FILENAME_LENGTH],RealName[MAX_FILENAME_LENGTH];
  183.  
  184.                                             strcpy(LocalBuffer,Directory);
  185.  
  186.                                             if(AddPart(LocalBuffer,FileInfo -> fib_FileName,MAX_FILENAME_LENGTH))
  187.                                             {
  188.                                                 if(ValidateFile(LocalBuffer,Type,RealName))
  189.                                                     AddFile(FileList,RealName);
  190.                                             }
  191.                                         }
  192.                                     }
  193.                                 }
  194.                             }
  195.                         }
  196.                     }
  197.                 }
  198.                 else
  199.                     break;
  200.             }
  201.             while(DevProc && (DevProc -> dvp_Flags & DVPF_ASSIGN));
  202.  
  203.                 /* Free the fileinfo data. */
  204.  
  205.             FreeDosObject(DOS_FIB,FileInfo);
  206.         }
  207.     }
  208.  
  209.         /* Reset the default filesystem task. */
  210.  
  211.     SetFileSysTask(FileSysTask);
  212.  
  213.         /* Free device process data. */
  214.  
  215.     if(DevProc)
  216.         FreeDeviceProc(DevProc);
  217. }
  218.  
  219.     /* FreeFileList(struct List *List):
  220.      *
  221.      *    Free a list and list contents.
  222.      */
  223.  
  224. STATIC VOID __regargs
  225. FreeFileList(struct List *List)
  226. {
  227.     struct Node    *Node,
  228.             *Next;
  229.  
  230.     Node = List -> lh_Head;
  231.  
  232.     while(Next = Node -> ln_Succ)
  233.     {
  234.         FreeVecPooled(Node);
  235.  
  236.         Node = Next;
  237.     }
  238.  
  239.     FreeVecPooled(List);
  240. }
  241.  
  242.     /* BuildFileList(STRPTR Directory,STRPTR Pattern):
  243.      *
  244.      *    Build a list of files in an assigned directory
  245.      *    matching a certain pattern.
  246.      */
  247.  
  248. STATIC struct List * __regargs
  249. BuildFileList(STRPTR Directory,STRPTR Pattern,LONG Type)
  250. {
  251.     APTR         OldPtr = ThisProcess -> pr_WindowPtr;
  252.     struct List    *FileList = NULL;
  253.     BPTR         NewDir;
  254.  
  255.         /* No DOS requesters, please! */
  256.  
  257.     ThisProcess -> pr_WindowPtr = (APTR)-1;
  258.  
  259.         /* Is the assignment present? */
  260.  
  261.     if(NewDir = Lock(Directory,ACCESS_READ))
  262.     {
  263.             /* Allocate space for the new list. */
  264.  
  265.         if(FileList = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
  266.         {
  267.                 /* Initialize the list. */
  268.  
  269.             NewList(FileList);
  270.  
  271.                 /* Will we have to deal with
  272.                  * an assignment or a volume?
  273.                  */
  274.  
  275.             if(IsAssign(Directory))
  276.                 FileMultiScan(FileList,Directory,Pattern,Type);
  277.             else
  278.             {
  279.                 struct FileInfoBlock    *FileInfo;
  280.                 UBYTE             MatchBuffer[MAX_FILENAME_LENGTH];
  281.  
  282.                 if(ParsePatternNoCase(Pattern,MatchBuffer,MAX_FILENAME_LENGTH) != -1)
  283.                 {
  284.                         /* Allocate space for a fileinfo block. */
  285.  
  286.                     if(FileInfo = (struct FileInfoBlock *)AllocDosObjectTags(DOS_FIB,TAG_DONE))
  287.                     {
  288.                             /* Take a look at the assignment. */
  289.  
  290.                         if(Examine(NewDir,FileInfo))
  291.                         {
  292.                                 /* Does it really refer to a directory? */
  293.  
  294.                             if(FileInfo -> fib_DirEntryType > 0)
  295.                             {
  296.                                     /* Examine the whole directory. */
  297.  
  298.                                 while(ExNext(NewDir,FileInfo))
  299.                                 {
  300.                                         /* Is it a file? */
  301.  
  302.                                     if(FileInfo -> fib_DirEntryType < 0)
  303.                                     {
  304.                                         if(MatchPatternNoCase(MatchBuffer,FileInfo -> fib_FileName))
  305.                                         {
  306.                                             if(Type == -1)
  307.                                                 AddFile(FileList,FileInfo -> fib_FileName);
  308.                                             else
  309.                                             {
  310.                                                 UBYTE LocalBuffer[MAX_FILENAME_LENGTH],RealName[MAX_FILENAME_LENGTH];
  311.  
  312.                                                 strcpy(LocalBuffer,Directory);
  313.  
  314.                                                 if(AddPart(LocalBuffer,FileInfo -> fib_FileName,MAX_FILENAME_LENGTH))
  315.                                                 {
  316.                                                     if(ValidateFile(LocalBuffer,Type,RealName))
  317.                                                         AddFile(FileList,RealName);
  318.                                                 }
  319.                                             }
  320.                                         }
  321.                                     }
  322.                                 }
  323.                             }
  324.                         }
  325.  
  326.                             /* Free the fileinfo data. */
  327.  
  328.                         FreeDosObject(DOS_FIB,FileInfo);
  329.                     }
  330.                 }
  331.             }
  332.  
  333.             if(Type == NT_DEVICE)
  334.             {
  335.                 UBYTE MatchBuffer[MAX_FILENAME_LENGTH];
  336.  
  337.                 if(ParsePatternNoCase(Pattern,MatchBuffer,MAX_FILENAME_LENGTH) != -1)
  338.                 {
  339.                     struct Node *Node;
  340.  
  341.                     Forbid();
  342.  
  343.                     for(Node = SysBase -> DeviceList . lh_Head ; Node -> ln_Succ ; Node = Node -> ln_Succ)
  344.                     {
  345.                         if(MatchPatternNoCase(MatchBuffer,Node -> ln_Name))
  346.                             AddFile(FileList,Node -> ln_Name);
  347.                     }
  348.  
  349.                     Permit();
  350.                 }
  351.             }
  352.  
  353.             if(Type == NT_LIBRARY)
  354.             {
  355.                 UBYTE MatchBuffer[MAX_FILENAME_LENGTH];
  356.  
  357.                 if(ParsePatternNoCase(Pattern,MatchBuffer,MAX_FILENAME_LENGTH) != -1)
  358.                 {
  359.                     struct Node *Node;
  360.  
  361.                     Forbid();
  362.  
  363.                     for(Node = SysBase -> LibList . lh_Head ; Node -> ln_Succ ; Node = Node -> ln_Succ)
  364.                     {
  365.                         if(MatchPatternNoCase(MatchBuffer,Node -> ln_Name))
  366.                             AddFile(FileList,Node -> ln_Name);
  367.                     }
  368.  
  369.                     Permit();
  370.                 }
  371.             }
  372.  
  373.                 /* Does the list contain any entries? */
  374.  
  375.             if(!FileList -> lh_Head -> ln_Succ)
  376.             {
  377.                 FreeVecPooled(FileList);
  378.  
  379.                 FileList = NULL;
  380.             }
  381.         }
  382.  
  383.             /* Release the lock on the directory. */
  384.  
  385.         UnLock(NewDir);
  386.     }
  387.  
  388.         /* Enable DOS requesters again. */
  389.  
  390.     ThisProcess -> pr_WindowPtr = OldPtr;
  391.  
  392.         /* Return the file name list. */
  393.  
  394.     return(FileList);
  395. }
  396.  
  397.     /* PickFile(STRPTR Directory,STRPTR Pattern,STRPTR Prompt,STRPTR Name):
  398.      *
  399.      *    Your nice file selection routine. No need to hunt for
  400.      *    a library/device by checking all assignments by hand.
  401.      */
  402.  
  403. BYTE __regargs
  404. PickFile(struct Window *Window,STRPTR Directory,STRPTR Pattern,STRPTR Prompt,STRPTR Name,LONG Type)
  405. {
  406.     UBYTE              DummyBuffer[MAX_FILENAME_LENGTH],
  407.                 *DummyChar;
  408.     struct FileRequester    *FileRequest;
  409.     struct List        *FileList;
  410.     BYTE             Result = FALSE;
  411.  
  412.     if(FileList = BuildFileList(Directory,Pattern,Type))
  413.     {
  414.         struct LayoutHandle *Handle;
  415.  
  416.         if(Handle = LT_CreateHandleTags(Window -> WScreen,
  417.             LH_LocaleHook,    &LocaleHook,
  418.         TAG_DONE))
  419.         {
  420.             struct Window    *PanelWindow;
  421.             ULONG         Index = (ULONG)~0,i;
  422.             struct Node    *Node;
  423.  
  424.             for(Node = FileList -> lh_Head, i = 0 ; Node -> ln_Succ ; Node = Node -> ln_Succ, i++)
  425.             {
  426.                 if(!Stricmp(Node -> ln_Name,Name))
  427.                 {
  428.                     Index = i;
  429.  
  430.                     break;
  431.                 }
  432.             }
  433.  
  434.             LT_New(Handle,
  435.                 LA_Type,    VERTICAL_KIND,
  436.             TAG_DONE);
  437.             {
  438.                 LT_New(Handle,
  439.                     LA_Type,    VERTICAL_KIND,
  440.                     LA_LabelID,    MSG_V36_1269,
  441.                 TAG_DONE);
  442.                 {
  443.                     LT_New(Handle,
  444.                         LA_Type,    LISTVIEW_KIND,
  445. /*                        LA_LabelID,    MSG_TERMPICKFILE_FILE_LIST_GAD,*/
  446.                         LA_Chars,    40,
  447.                         LA_ID,        GAD_LIST,
  448.                         LA_Lines,    10,
  449.                         LALV_MaxGrowY,    20,
  450.                         LALV_ResizeY,    TRUE,
  451.                         GTLV_Labels,    FileList,
  452.                         GTLV_Selected,    Index,
  453.                         LALV_Link,    NIL_LINK,
  454.                         LALV_CursorKey,    TRUE,
  455.                     TAG_DONE);
  456.  
  457.                     LT_EndGroup(Handle);
  458.                 }
  459.  
  460.                 LT_New(Handle,
  461.                     LA_Type,VERTICAL_KIND,
  462.                 TAG_DONE);
  463.                 {
  464.                     LT_New(Handle,
  465.                         LA_Type,    XBAR_KIND,
  466.                         LAXB_FullSize,    TRUE,
  467.                     TAG_DONE);
  468.  
  469.                     LT_EndGroup(Handle);
  470.                 }
  471.  
  472.                 LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  473.                     LAGR_SameSize,    TRUE,
  474.                     LAGR_Spread,    TRUE,
  475.                 TAG_DONE);
  476.                 {
  477.                     LT_New(Handle,
  478.                         LA_Type,    BUTTON_KIND,
  479.                         LA_LabelID,    MSG_GLOBAL_USE_GAD,
  480.                         LA_ID,        GAD_USE,
  481.                         LABT_ReturnKey,    TRUE,
  482.                         LABT_ExtraFat,    TRUE,
  483.                     TAG_DONE);
  484.  
  485.                     LT_New(Handle,
  486.                         LA_Type,    BUTTON_KIND,
  487.                         LA_LabelID,    MSG_TERMPICKFILE_SELECT_GAD,
  488.                         LA_ID,        GAD_SELECT,
  489.                         LABT_ExtraFat,    TRUE,
  490.                     TAG_DONE);
  491.  
  492.                     LT_New(Handle,
  493.                         LA_Type,    BUTTON_KIND,
  494.                         LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  495.                         LA_ID,        GAD_CANCEL,
  496.                         LABT_EscKey,    TRUE,
  497.                         LABT_ExtraFat,    TRUE,
  498.                     TAG_DONE);
  499.  
  500.                     LT_EndGroup(Handle);
  501.                 }
  502.  
  503.                 LT_EndGroup(Handle);
  504.             }
  505.  
  506.             if(PanelWindow = LT_Layout(Handle,Prompt,NULL,0,0,IDCMP_CLOSEWINDOW,0,
  507.                 LAWN_HelpHook,        &GuideHook,
  508.                 LAWN_Parent,        Window,
  509.                 WA_DepthGadget,        TRUE,
  510.                 WA_CloseGadget,        TRUE,
  511.                 WA_DragBar,        TRUE,
  512.                 WA_RMBTrap,        TRUE,
  513.                 WA_Activate,        TRUE,
  514.             TAG_DONE))
  515.             {
  516.                 struct IntuiMessage    *Message;
  517.                 BOOLEAN             Done = FALSE;
  518.                 ULONG             MsgClass,
  519.                              MsgQualifier;
  520.                 UWORD             MsgCode;
  521.                 struct Gadget        *MsgGadget;
  522.  
  523.                 LT_ShowWindow(Handle,TRUE);
  524.  
  525.                 PushWindow(PanelWindow);
  526.  
  527.                 do
  528.                 {
  529.                     if(Wait(PORTMASK(PanelWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
  530.                         break;
  531.  
  532.                     while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  533.                     {
  534.                         MsgClass    = Message -> Class;
  535.                         MsgQualifier    = Message -> Qualifier;
  536.                         MsgCode        = Message -> Code;
  537.                         MsgGadget    = (struct Gadget *)Message -> IAddress;
  538.  
  539.                         LT_ReplyIMsg(Message);
  540.  
  541.                         if(MsgClass == IDCMP_CLOSEWINDOW)
  542.                             Done = TRUE;
  543.  
  544.                         if(MsgClass == IDCMP_GADGETUP)
  545.                         {
  546.                             switch(MsgGadget -> GadgetID)
  547.                             {
  548.                                 case GAD_USE:
  549.  
  550.                                     if(Index != (ULONG)~0)
  551.                                     {
  552.                                         struct Node *Node = GetListNode(Index,FileList);
  553.  
  554.                                         if(Node)
  555.                                         {
  556.                                             strcpy(Name,Node -> ln_Name);
  557.  
  558.                                             Result = TRUE;
  559.                                         }
  560.                                     }
  561.  
  562.                                     Done = TRUE;
  563.                                     break;
  564.  
  565.                                 case GAD_CANCEL:
  566.  
  567.                                     Done = TRUE;
  568.                                     break;
  569.  
  570.                                 case GAD_LIST:
  571.  
  572.                                     Index = MsgCode;
  573.                                     break;
  574.  
  575.                                 case GAD_SELECT:
  576.  
  577.                                     LT_LockWindow(PanelWindow);
  578.  
  579.                                     SplitFileName(Name,&DummyChar,DummyBuffer);
  580.  
  581.                                     if(FileRequest = GetFile(PanelWindow,Prompt,DummyBuffer,DummyChar,DummyBuffer,Pattern,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  582.                                     {
  583.                                         STRPTR FileName;
  584.  
  585.                                         if(FileRequest -> rf_NumArgs > 1 && FileRequest -> rf_ArgList)
  586.                                             FileName = FileRequest -> rf_ArgList -> wa_Name;
  587.                                         else
  588.                                             FileName = FileRequest -> rf_File;
  589.  
  590.                                         if(!Stricmp(FileRequest -> rf_Dir,Directory))
  591.                                             strcpy(Name,FileName);
  592.                                         else
  593.                                             strcpy(Name,DummyBuffer);
  594.  
  595.                                         if(Type != -1)
  596.                                         {
  597.                                             UBYTE LocalBuffer[MAX_FILENAME_LENGTH];
  598.  
  599.                                             if(!Stricmp(FileRequest -> rf_Dir,Directory))
  600.                                             {
  601.                                                 strcpy(LocalBuffer,Directory);
  602.  
  603.                                                 if(AddPart(LocalBuffer,Name,MAX_FILENAME_LENGTH))
  604.                                                     ValidateFile(LocalBuffer,Type,Name);
  605.                                             }
  606.                                             else
  607.                                             {
  608.                                                 if(ValidateFile(DummyBuffer,Type,LocalBuffer))
  609.                                                 {
  610.                                                     strcpy(Name,DummyBuffer);
  611.  
  612.                                                     DummyChar = PathPart(Name);
  613.  
  614.                                                     *DummyChar = 0;
  615.  
  616.                                                     AddPart(Name,LocalBuffer,MAX_FILENAME_LENGTH);
  617.                                                 }
  618.                                             }
  619.                                         }
  620.  
  621.                                         FreeAslRequest(FileRequest);
  622.  
  623.                                         Done = Result = TRUE;
  624.                                     }
  625.  
  626.                                     LT_UnlockWindow(PanelWindow);
  627.  
  628.                                     break;
  629.                             }
  630.                         }
  631.  
  632.                         if(MsgClass == IDCMP_IDCMPUPDATE)
  633.                         {
  634.                             struct Node *Node = GetListNode(Index = MsgCode,FileList);
  635.  
  636.                             if(Node)
  637.                             {
  638.                                 strcpy(Name,Node -> ln_Name);
  639.  
  640.                                 Done = Result = TRUE;
  641.  
  642.                                 LT_PressButton(Handle,GAD_USE);
  643.                             }
  644.                         }
  645.                     }
  646.                 }
  647.                 while(!Done);
  648.  
  649.                 PopWindow();
  650.             }
  651.  
  652.             LT_DeleteHandle(Handle);
  653.         }
  654.  
  655.         DeleteList(FileList);
  656.     }
  657.     else
  658.     {
  659.         SplitFileName(Name,&DummyChar,DummyBuffer);
  660.  
  661.         if(FileRequest = GetFile(Window,Prompt,DummyBuffer,DummyChar,DummyBuffer,Pattern,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  662.         {
  663.             STRPTR FileName;
  664.  
  665.             if(FileRequest -> rf_NumArgs > 1 && FileRequest -> rf_ArgList)
  666.                 FileName = FileRequest -> rf_ArgList -> wa_Name;
  667.             else
  668.                 FileName = FileRequest -> rf_File;
  669.  
  670.             if(!Stricmp(FileRequest -> rf_Dir,Directory))
  671.                 strcpy(Name,FileName);
  672.             else
  673.                 strcpy(Name,DummyBuffer);
  674.  
  675.             if(Type != -1)
  676.             {
  677.                 UBYTE LocalBuffer[MAX_FILENAME_LENGTH];
  678.  
  679.                 if(!Stricmp(FileRequest -> rf_Dir,Directory))
  680.                 {
  681.                     strcpy(LocalBuffer,Directory);
  682.  
  683.                     if(AddPart(LocalBuffer,Name,MAX_FILENAME_LENGTH))
  684.                         ValidateFile(LocalBuffer,Type,Name);
  685.                 }
  686.                 else
  687.                 {
  688.                     if(ValidateFile(DummyBuffer,Type,LocalBuffer))
  689.                     {
  690.                         strcpy(Name,DummyBuffer);
  691.  
  692.                         DummyChar = PathPart(Name);
  693.  
  694.                         *DummyChar = 0;
  695.  
  696.                         AddPart(Name,LocalBuffer,MAX_FILENAME_LENGTH);
  697.                     }
  698.                 }
  699.             }
  700.  
  701.             FreeAslRequest(FileRequest);
  702.  
  703.             return(TRUE);
  704.         }
  705.     }
  706.  
  707.     return(Result);
  708. }
  709.